<!DOCTYPE html>
<html lang="en" dir="ltr" class="client-nojs">
<head>
<title>Type - cppreference.com</title>
<meta charset="UTF-8">
<meta name="generator" content="MediaWiki 1.21.2">
<link rel="shortcut icon" href="../../../common/favicon.ico">
<link rel="stylesheet" href="../../../common/ext.css">
<meta name="ResourceLoaderDynamicStyles" content="">
<link rel="stylesheet" href="../../../common/site_modules.css">
<style>a:lang(ar),a:lang(ckb),a:lang(fa),a:lang(kk-arab),a:lang(mzn),a:lang(ps),a:lang(ur){text-decoration:none}#toc{display:none}.editsection{display:none}
/* cache key: mwiki1-mwiki_en_:resourceloader:filter:minify-css:7:472787eddcf4605d11de8c7ef047234f */</style>

<script src="../../../common/startup_scripts.js"></script>
<script>if(window.mw){
mw.config.set({"wgCanonicalNamespace":"","wgCanonicalSpecialPageName":false,"wgNamespaceNumber":0,"wgPageName":"c/language/type","wgTitle":"c/language/type","wgCurRevisionId":136122,"wgArticleId":13744,"wgIsArticle":true,"wgAction":"view","wgUserName":null,"wgUserGroups":["*"],"wgCategories":[],"wgBreakFrames":false,"wgPageContentLanguage":"en","wgSeparatorTransformTable":["",""],"wgDigitTransformTable":["",""],"wgDefaultDateFormat":"dmy","wgMonthNames":["","January","February","March","April","May","June","July","August","September","October","November","December"],"wgMonthNamesShort":["","Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"],"wgRelevantPageName":"c/language/type","wgRestrictionEdit":[],"wgRestrictionMove":[]});
}</script><script>if(window.mw){
mw.loader.implement("user.options",function(){mw.user.options.set({"ccmeonemails":0,"cols":80,"date":"default","diffonly":0,"disablemail":0,"disablesuggest":0,"editfont":"default","editondblclick":0,"editsection":0,"editsectiononrightclick":0,"enotifminoredits":0,"enotifrevealaddr":0,"enotifusertalkpages":1,"enotifwatchlistpages":0,"extendwatchlist":0,"externaldiff":0,"externaleditor":0,"fancysig":0,"forceeditsummary":0,"gender":"unknown","hideminor":0,"hidepatrolled":0,"imagesize":2,"justify":0,"math":1,"minordefault":0,"newpageshidepatrolled":0,"nocache":0,"noconvertlink":0,"norollbackdiff":0,"numberheadings":0,"previewonfirst":0,"previewontop":1,"quickbar":5,"rcdays":7,"rclimit":50,"rememberpassword":0,"rows":25,"searchlimit":20,"showhiddencats":0,"showjumplinks":1,"shownumberswatching":1,"showtoc":0,"showtoolbar":1,"skin":"cppreference2","stubthreshold":0,"thumbsize":2,"underline":2,"uselivepreview":0,"usenewrc":0,"watchcreations":0,"watchdefault":0,"watchdeletion":0,
"watchlistdays":3,"watchlisthideanons":0,"watchlisthidebots":0,"watchlisthideliu":0,"watchlisthideminor":0,"watchlisthideown":0,"watchlisthidepatrolled":0,"watchmoves":0,"wllimit":250,"variant":"en","language":"en","searchNs0":true,"searchNs1":false,"searchNs2":false,"searchNs3":false,"searchNs4":false,"searchNs5":false,"searchNs6":false,"searchNs7":false,"searchNs8":false,"searchNs9":false,"searchNs10":false,"searchNs11":false,"searchNs12":false,"searchNs13":false,"searchNs14":false,"searchNs15":false,"gadget-ColiruCompiler":1,"gadget-MathJax":1});;},{},{});mw.loader.implement("user.tokens",function(){mw.user.tokens.set({"editToken":"+\\","patrolToken":false,"watchToken":false});;},{},{});
/* cache key: mwiki1-mwiki_en_:resourceloader:filter:minify-js:7:9f05c6caceb9bb1a482b6cebd4c5a330 */
}</script>
<script>if(window.mw){
mw.loader.load(["mediawiki.page.startup","mediawiki.legacy.wikibits","mediawiki.legacy.ajax"]);
}</script>
<style type="text/css">/*<![CDATA[*/
.source-c {line-height: normal;}
.source-c li, .source-c pre {
	line-height: normal; border: 0px none white;
}
/**
 * GeSHi Dynamically Generated Stylesheet
 * --------------------------------------
 * Dynamically generated stylesheet for c
 * CSS class: source-c, CSS id: 
 * GeSHi (C) 2004 - 2007 Nigel McNie, 2007 - 2008 Benny Baumann
 * (http://qbnz.com/highlighter/ and http://geshi.org/)
 * --------------------------------------
 */
.c.source-c .de1, .c.source-c .de2 {font: normal normal 1em/1.2em monospace; margin:0; padding:0; background:none; vertical-align:top;}
.c.source-c  {font-family:monospace;}
.c.source-c .imp {font-weight: bold; color: red;}
.c.source-c li, .c.source-c .li1 {font-weight: normal; vertical-align:top;}
.c.source-c .ln {width:1px;text-align:right;margin:0;padding:0 2px;vertical-align:top;}
.c.source-c .li2 {font-weight: bold; vertical-align:top;}
.c.source-c .kw1 {color: #0000dd;}
.c.source-c .kw2 {color: #0000ff;}
.c.source-c .kw3 {color: #0000dd;}
.c.source-c .kw4 {color: #0000ff;}
.c.source-c .co1 {color: #909090;}
.c.source-c .co2 {color: #339900;}
.c.source-c .coMULTI {color: #ff0000; font-style: italic;}
.c.source-c .es0 {color: #008000; font-weight: bold;}
.c.source-c .es1 {color: #008000; font-weight: bold;}
.c.source-c .es2 {color: #008000; font-weight: bold;}
.c.source-c .es3 {color: #008000; font-weight: bold;}
.c.source-c .es4 {color: #008000; font-weight: bold;}
.c.source-c .es5 {color: #008000; font-weight: bold;}
.c.source-c .br0 {color: #008000;}
.c.source-c .sy0 {color: #008000;}
.c.source-c .sy1 {color: #000080;}
.c.source-c .sy2 {color: #000040;}
.c.source-c .sy3 {color: #000040;}
.c.source-c .sy4 {color: #008080;}
.c.source-c .st0 {color: #008000;}
.c.source-c .nu0 {color: #000080;}
.c.source-c .nu6 {color:#000080;}
.c.source-c .nu8 {color:#000080;}
.c.source-c .nu12 {color:#000080;}
.c.source-c .nu16 {color:#000080;}
.c.source-c .nu17 {color:#000080;}
.c.source-c .nu18 {color:#000080;}
.c.source-c .nu19 {color:#000080;}
.c.source-c .ln-xtra, .c.source-c li.ln-xtra, .c.source-c div.ln-xtra {background-color: #ffc;}
.c.source-c span.xtra { display:block; }

/*]]>*/
</style><!--[if lt IE 7]><style type="text/css">body{behavior:url("/mwiki/skins/cppreference2/csshover.min.htc")}</style><![endif]--></head>
<body class="mediawiki ltr sitedir-ltr ns-0 ns-subject page-c_language_type skin-cppreference2 action-view cpp-navbar">
        <!-- header -->
        <!-- /header -->
        <!-- content -->
<div id="cpp-content-base">
            <div id="content">
                <a id="top"></a>
                <div id="mw-js-message" style="display:none;"></div>
                                <!-- firstHeading -->
<h1 id="firstHeading" class="firstHeading">Type</h1>
                <!-- /firstHeading -->
                <!-- bodyContent -->
                <div id="bodyContent">
                                        <!-- tagline -->
                    <div id="siteSub">From cppreference.com</div>
                    <!-- /tagline -->
                                        <!-- subtitle -->
                    <div id="contentSub"><span class="subpages">&lt; <a href="../../c.html" title="c">c</a>‎ | <a href="../language.html" title="c/language">language</a></span></div>
                    <!-- /subtitle -->
                                                            <!-- bodycontent -->
                    <div id="mw-content-text" lang="en" dir="ltr" class="mw-content-ltr"><div class="t-navbar" style=""><div class="t-navbar-sep"> </div><div class="t-navbar-head"><a href="../../c.html" title="c"> C</a><div class="t-navbar-menu"><div><div><table class="t-nv-begin" cellpadding="0" style="line-height:1.1em;">
<tr class="t-nv"><td colspan="5"> <a href="../language.html" title="c/language"> Language</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../header.html" title="c/header"> Headers</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../types.html" title="c/types"> Type support</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../program.html" title="c/program"> Program utilities</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../variadic.html" title="c/variadic"> Variadic function support</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../error.html" title="c/error"> Error handling</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../memory.html" title="c/memory"> Dynamic memory management</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../string.html" title="c/string"> Strings library</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../algorithm.html" title="c/algorithm"> Algorithms</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../numeric.html" title="c/numeric"> Numerics</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../chrono.html" title="c/chrono"> Date and time utilities</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../io.html" title="c/io"> Input/output support</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../locale.html" title="c/locale"> Localization support</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../thread.html" title="c/thread"> Concurrency support</a> <span class="t-mark-rev t-since-c11">(C11)</span> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../experimental.html" title="c/experimental"> Technical Specifications</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../index.html" title="c/symbol index"> Symbol index</a> </td></tr>
</table></div><div></div></div></div></div><div class="t-navbar-sep"> </div><div class="t-navbar-head"><a href="../language.html" title="c/language"> C language</a><div class="t-navbar-menu"><div><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="basic_concepts.html" title="c/language/basic concepts">Basic concepts</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../keyword.html" title="c/keyword"> Keywords</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../preprocessor.html" title="c/preprocessor"> Preprocessor</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="statements.html" title="c/language/statements"> Statements</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="expressions.html" title="c/language/expressions"> Expressions</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="initialization.html" title="c/language/initialization"> Initialization</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="declarations.html" title="c/language/declarations"> Declarations</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="functions.html" title="c/language/functions"> Functions</a></td></tr>
<tr class="t-nv-h2"><td colspan="5"> Miscellaneous</td></tr>
<tr class="t-nv"><td colspan="5"> <a href="history.html" title="c/language/history"> History of C</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../experimental.html" title="c/experimental">Technical Specifications</a> </td></tr>
</table></div><div></div></div></div></div><div class="t-navbar-sep"> </div><div class="t-navbar-head"><a href="basic_concepts.html" title="c/language/basic concepts"> Basic Concepts</a><div class="t-navbar-menu"><div><div style="display:inline-block">
<div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="../comment.html" title="c/comment"> Comments</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="ascii.html" title="c/language/ascii"> ASCII</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="translation_phases.html" title="c/language/translation phases"> Translation phases</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="punctuators.html" title="c/language/punctuators">Punctuation</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="identifier.html" title="c/language/identifier">Identifier</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="scope.html" title="c/language/scope">Scope</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="lifetime.html" title="c/language/lifetime">Lifetime</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="name_space.html" title="c/language/name space">Lookup and name spaces</a></td></tr>
<tr class="t-nv"><td colspan="5"> <strong class="selflink">Type</strong></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="arithmetic_types.html" title="c/language/arithmetic types">Arithmetic types</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="object.html" title="c/language/object">Objects and alignment</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="main_function.html" title="c/language/main function">The main() function</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="as_if.html" title="c/language/as if">The as-if rule</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="behavior.html" title="c/language/behavior">Undefined behavior</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="memory_model.html" title="c/language/memory model">Memory model and data races</a></td></tr>
</table></div>
</div><div></div></div></div></div><div class="t-navbar-sep"> </div></div>
<p><small>(See also <a href="arithmetic_types.html" title="c/language/arithmetic types">arithmetic types</a> for the details on most built-in types and <a href="../types.html" title="c/types"> the list of type-related utilities</a> that are provided by the C library)</small>
</p><p><a href="object.html" title="c/language/object">Objects</a>, <a href="functions.html" title="c/language/functions">functions</a>, and <a href="expressions.html" title="c/language/expressions">expressions</a> have a property called <i>type</i>, which determines the interpretation of the binary value stored in an object or evaluated by the expression.
</p>
<h3><span class="mw-headline" id="Type_classification">Type classification</span></h3>
<p>The C type system consists of the following types:
</p>
<ul><li>the type <span class="t-c"><span class="mw-geshi c source-c"><span class="kw4">void</span></span></span>
</li><li>basic types
</li></ul>
<dl><dd><ul><li>the type <span class="t-c"><span class="mw-geshi c source-c"><span class="kw4">char</span></span></span>
</li><li>signed integer types
</li></ul>
<dl><dd><ul><li>standard: <span class="t-c"><span class="mw-geshi c source-c"><span class="kw4">signed</span> <span class="kw4">char</span></span></span>, <span class="t-c"><span class="mw-geshi c source-c"><span class="kw4">short</span></span></span>, <span class="t-c"><span class="mw-geshi c source-c"><span class="kw4">int</span></span></span>, <span class="t-c"><span class="mw-geshi c source-c"><span class="kw4">long</span></span></span><span class="t-rev-inl t-since-c99"><span>, <span class="t-c"><span class="mw-geshi c source-c"><span class="kw4">long</span> <span class="kw4">long</span></span></span></span> <span><span class="t-mark-rev t-since-c99">(since C99)</span></span></span>
</li></ul>
</dd></dl>
</dd></dl>
 <table class="t-rev-begin">
<tr class="t-rev t-since-c99"><td>
<dl><dd><dl><dd><ul><li>extended: implementation defined, e.g. <span class="t-c"><span class="mw-geshi c source-c">__int128</span></span>
</li></ul>
</dd></dl>
</dd></dl>
</td>
<td><span class="t-mark-rev t-since-c99">(since C99)</span></td></tr>
</table>
<dl><dd><ul><li>unsigned integer types
</li></ul>
<dl><dd><ul><li>standard: <span class="t-rev-inl t-since-c99"><span><span class="t-c"><span class="mw-geshi c source-c">_Bool</span></span>,</span> <span><span class="t-mark-rev t-since-c99">(since C99)</span></span></span> <span class="t-c"><span class="mw-geshi c source-c"><span class="kw4">unsigned</span> <span class="kw4">char</span></span></span>, <span class="t-c"><span class="mw-geshi c source-c"><span class="kw4">unsigned</span> <span class="kw4">short</span></span></span>, <span class="t-c"><span class="mw-geshi c source-c"><span class="kw4">unsigned</span> <span class="kw4">int</span></span></span>, <span class="t-c"><span class="mw-geshi c source-c"><span class="kw4">unsigned</span> <span class="kw4">long</span></span></span><span class="t-rev-inl t-since-c99"><span>, <span class="t-c"><span class="mw-geshi c source-c"><span class="kw4">unsigned</span> <span class="kw4">long</span> <span class="kw4">long</span></span></span></span> <span><span class="t-mark-rev t-since-c99">(since C99)</span></span></span>
</li></ul>
</dd></dl>
</dd></dl>
 <table class="t-rev-begin">
<tr class="t-rev t-since-c99"><td>
<dl><dd><dl><dd><ul><li>extended: implementation-defined, e.g. <span class="t-c"><span class="mw-geshi c source-c">__uint128</span></span>
</li></ul>
</dd></dl>
</dd></dl>
</td>
<td><span class="t-mark-rev t-since-c99">(since C99)</span></td></tr>
</table>
<dl><dd><ul><li>floating-point types
</li></ul>
<dl><dd><ul><li>real floating-point types: <span class="t-c"><span class="mw-geshi c source-c"><span class="kw4">float</span></span></span>, <span class="t-c"><span class="mw-geshi c source-c"><span class="kw4">double</span></span></span>, <span class="t-c"><span class="mw-geshi c source-c"><span class="kw4">long</span> <span class="kw4">double</span></span></span>
</li></ul>
</dd></dl>
</dd></dl>
 <table class="t-rev-begin">
<tr class="t-rev t-since-c23"><td>
<dl><dd><dl><dd><ul><li>decimal real floating-point types: <span class="t-c"><span class="mw-geshi c source-c">_Decimal32</span></span>, <span class="t-c"><span class="mw-geshi c source-c">_Decimal64</span></span>, <span class="t-c"><span class="mw-geshi c source-c">_Decimal128</span></span>
</li></ul>
</dd></dl>
</dd></dl>
</td>
<td><span class="t-mark-rev t-since-c23">(since C23)</span></td></tr>
<tr class="t-rev t-since-c99"><td>
<dl><dd><dl><dd><ul><li>complex types: <span class="t-c"><span class="mw-geshi c source-c"><span class="kw4">float</span> _Complex</span></span>, <span class="t-c"><span class="mw-geshi c source-c"><span class="kw4">double</span> _Complex</span></span>, <span class="t-c"><span class="mw-geshi c source-c"><span class="kw4">long</span> <span class="kw4">double</span> _Complex</span></span>
</li><li>imaginary types: <span class="t-c"><span class="mw-geshi c source-c"><span class="kw4">float</span> _Imaginary</span></span>, <span class="t-c"><span class="mw-geshi c source-c"><span class="kw4">double</span> _Imaginary</span></span>, <span class="t-c"><span class="mw-geshi c source-c"><span class="kw4">long</span> <span class="kw4">double</span> _Imaginary</span></span>
</li></ul>
</dd></dl>
</dd></dl>
</td>
<td><span class="t-mark-rev t-since-c99">(since C99)</span></td></tr>
</table>
<ul><li> <a href="enum.html" title="c/language/enum">enumerated types</a>
</li></ul>
<ul><li> derived types
</li></ul>
<dl><dd><ul><li> <a href="array.html" title="c/language/array">array types</a>
</li><li> <a href="struct.html" title="c/language/struct">structure types</a>
</li><li> <a href="union.html" title="c/language/union">union types</a>
</li><li> <a href="functions.html" title="c/language/functions">function types</a>
</li><li> <a href="pointer.html" title="c/language/pointer">pointer types</a>
</li></ul>
</dd></dl>
 <table class="t-rev-begin">
<tr class="t-rev t-since-c11"><td>
<dl><dd><ul><li> <a href="atomic.html" title="c/language/atomic">atomic types</a>
</li></ul>
</dd></dl>
</td>
<td><span class="t-mark-rev t-since-c11">(since C11)</span></td></tr>
</table>
<p>For every type listed above several qualified versions of its type may exist, corresponding to the combinations of one, two, or all three of the <a href="const.html" title="c/language/const"><code>const</code></a>, <a href="volatile.html" title="c/language/volatile"><code>volatile</code></a>, and <a href="restrict.html" title="c/language/restrict"><code>restrict</code></a> qualifiers (where allowed by the qualifier's semantics).
</p>
<h4><span class="mw-headline" id="Type_groups">Type groups</span></h4>
<ul><li> <i>object types</i>: all types that aren't function types
</li><li> <i>character types</i>: <span class="t-c"><span class="mw-geshi c source-c"><span class="kw4">char</span></span></span>, <span class="t-c"><span class="mw-geshi c source-c"><span class="kw4">signed</span> <span class="kw4">char</span></span></span>, <span class="t-c"><span class="mw-geshi c source-c"><span class="kw4">unsigned</span> <span class="kw4">char</span></span></span>
</li><li> <i>integer types</i>: <span class="t-c"><span class="mw-geshi c source-c"><span class="kw4">char</span></span></span>, signed integer types, unsigned integer types, enumerated types
</li><li> <i>real types</i>: integer types and real floating types 
</li><li> <a href="arithmetic_types.html" title="c/language/arithmetic types">arithmetic types</a>: integer types and floating types
</li><li> <i>scalar types</i>: arithmetic types and pointer types
</li><li> <i>aggregate types</i>: array types and structure types
</li><li> <i>derived declarator types</i>: array types, function types, and pointer types
</li></ul>
<h3><span class="mw-headline" id="Compatible_types">Compatible types</span></h3>
<p>In a C program, the declarations referring to the same object or function in <i>different translation units</i> do not have to use the same type. They only have to use sufficiently similar types, formally known as <i>compatible types</i>. Same applies to function calls and lvalue accesses; argument types must be <i>compatible</i> with parameter types and lvalue expression type must be <i>compatible</i> with the object type that is accessed.
</p><p>The types <code>T</code> and <code>U</code> are compatible, if
</p>
<ul><li> they are the same type (same name or aliases introduced by a <a href="typedef.html" title="c/language/typedef">typedef</a>)
</li><li> they are identically cvr-qualified versions of compatible unqualified types
</li><li> they are pointer types and are pointing to compatible types
</li><li> they are array types, and
</li></ul>
<dl><dd><ul><li> their element types are compatible, and
</li><li> if both have constant size, that size is the same. Note: arrays of unknown bound are compatible with any array of compatible element type. <span class="t-rev-inl t-since-c99"><span>VLA is compatible with any array of compatible element type.</span> <span><span class="t-mark-rev t-since-c99">(since C99)</span></span></span>
</li></ul>
</dd></dl>
<ul><li> they are both structure/union/enumeration types, and
</li></ul>
<dl><dd><ul><li><span class="t-mark-rev t-since-c99">(C99)</span>if one is declared with a tag, the other must also be declared with the same tag.
</li><li> if both are completed types, their members must correspond exactly in number, be declared with compatible types, and have matching names.
</li><li> additionally, if they are enumerations, corresponding members must also have the same values.
</li><li> additionally, if they are structures or unions,
</li></ul>
<dl><dd><ul><li> Corresponding members must be declared in the same order (structures only)
</li><li> Corresponding bit fields must have the same widths.
</li></ul>
</dd></dl>
</dd></dl>
<ul><li> one is an enumerated type and the other is that enumeration's underlying type
</li><li> they are function types, and
</li></ul>
<dl><dd><ul><li> their return types are compatible
</li><li> they both use parameter lists, the number of parameters (including the use of the ellipsis) is the same, and the corresponding parameter, after applying array-to-pointer and function-to-pointer type adjustments and after stripping top-level qualifiers, have compatible types
</li><li> one is an old-style (parameter-less) definition, the other has a parameter list, the parameter list does not use an ellipsis and each parameter is compatible (after function parameter type adjustment) with the corresponding old-style parameter after default argument promotions
</li><li> one is an old-style (parameter-less) declaration, the other has a parameter list, the parameter list does not use an ellipsis, and all parameters (after function parameter type adjustment) are unaffected by default argument promotions
</li></ul>
</dd></dl>
<p>The type <span class="t-c"><span class="mw-geshi c source-c"><span class="kw4">char</span></span></span> is not compatible with <span class="t-c"><span class="mw-geshi c source-c"><span class="kw4">signed</span> <span class="kw4">char</span></span></span> and not compatible with <span class="t-c"><span class="mw-geshi c source-c"><span class="kw4">unsigned</span> <span class="kw4">char</span></span></span>.
</p><p>If two declarations refer to the same object or function and do not use compatible types, the behavior of the program is undefined.
</p>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="c source-c"><pre class="de1"><span class="co1">// Translation Unit 1</span>
<span class="kw1">struct</span> S <span class="br0">{</span><span class="kw4">int</span> a<span class="sy4">;</span><span class="br0">}</span><span class="sy4">;</span>
<span class="kw2">extern</span> <span class="kw1">struct</span> S <span class="sy2">*</span>x<span class="sy4">;</span>  <span class="co1">// compatible with TU2's x, but not with TU3's x</span>
<span class="co1">// Translation Unit 2</span>
<span class="kw1">struct</span> S<span class="sy4">;</span>
<span class="kw2">extern</span> <span class="kw1">struct</span> S <span class="sy2">*</span>x<span class="sy4">;</span> <span class="co1">// compatible with both x's</span>
<span class="co1">// Translation Unit 3</span>
<span class="kw1">struct</span> S <span class="br0">{</span><span class="kw4">float</span> a<span class="sy4">;</span><span class="br0">}</span><span class="sy4">;</span>
<span class="kw2">extern</span> <span class="kw1">struct</span> S <span class="sy2">*</span>x<span class="sy4">;</span> <span class="co1">// compatible with TU2's x, but not with TU1's x</span>
 
<span class="co1">// the behavior is undefined</span></pre></div></div>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="c source-c"><pre class="de1"><span class="co1">// Translation Unit 1</span>
<span class="co2">#include &lt;stdio.h&gt;</span>
<span class="kw1">struct</span> s <span class="br0">{</span><span class="kw4">int</span> i<span class="sy4">;</span><span class="br0">}</span><span class="sy4">;</span> <span class="co1">// compatible with TU3's s, but not TU2's</span>
<span class="kw2">extern</span> <span class="kw1">struct</span> s x <span class="sy1">=</span> <span class="br0">{</span><span class="nu0">0</span><span class="br0">}</span><span class="sy4">;</span> <span class="co1">// compatible with TU3's x</span>
<span class="kw2">extern</span> <span class="kw4">void</span> f<span class="br0">(</span><span class="kw4">void</span><span class="br0">)</span><span class="sy4">;</span> <span class="co1">// compatible with TU2's f</span>
<span class="kw4">int</span> main<span class="br0">(</span><span class="br0">)</span>
<span class="br0">{</span>
   f<span class="br0">(</span><span class="br0">)</span><span class="sy4">;</span>
   <span class="kw1">return</span> x.<span class="me1">i</span><span class="sy4">;</span>
<span class="br0">}</span>
<span class="co1">// Translation Unit 2</span>
<span class="kw1">struct</span> s <span class="br0">{</span><span class="kw4">float</span> f<span class="sy4">;</span><span class="br0">}</span><span class="sy4">;</span> <span class="co1">// compatible with TU4's s, but not TU1's s</span>
<span class="kw2">extern</span> <span class="kw1">struct</span> s y <span class="sy1">=</span> <span class="br0">{</span><span class="nu16">3.14</span><span class="br0">}</span><span class="sy4">;</span> <span class="co1">// compatible with TU4's y</span>
<span class="kw4">void</span> f<span class="br0">(</span><span class="br0">)</span> <span class="co1">// compatible with TU1's f</span>
<span class="br0">{</span>
   <span class="kw1">return</span><span class="sy4">;</span>
<span class="br0">}</span>
<span class="co1">// Translation Unit 3</span>
<span class="kw1">struct</span> s <span class="br0">{</span><span class="kw4">int</span> i<span class="sy4">;</span><span class="br0">}</span><span class="sy4">;</span> <span class="co1">// compatible with TU1's s, but not TU2's s</span>
<span class="kw2">extern</span> <span class="kw1">struct</span> s x<span class="sy4">;</span> <span class="co1">// compatible with TU1's x</span>
<span class="co1">// Translation Unit 4</span>
<span class="kw1">struct</span> s <span class="br0">{</span><span class="kw4">float</span> f<span class="sy4">;</span><span class="br0">}</span><span class="sy4">;</span> <span class="co1">// compatible with TU2's s, but not TU1's s</span>
<span class="kw2">extern</span> <span class="kw1">struct</span> s y<span class="sy4">;</span> <span class="co1">// compatible with TU2's y</span>
 
<span class="co1">// the behavior is well-defined: only multiple declarations</span>
<span class="co1">// of objects and functions must have compatible types, not the types themselves</span></pre></div></div>
<p>Note: C++ has no concept of compatible types. A C program that declares two types that are compatible but not identical in different translation units is not a valid C++ program.
</p>
<h3><span class="mw-headline" id="Composite_types">Composite types</span></h3>
<p>A composite type can be constructed from two types that are compatible; it is a type that
is compatible with both of the two types and satisfies the following conditions:
</p>
<ul><li>If both types are array types, the following rules are applied:
</li></ul>
<dl><dd><ul><li>If one type is an array of known constant size, the composite type is an array of that size.
</li></ul>
</dd></dl>
 <table class="t-rev-begin">
<tr class="t-rev t-since-c99"><td>
<dl><dd><ul><li>Otherwise, if one type is a VLA whose size is specified by an expression that is not evaluated, the behavior is undefined.
</li><li>Otherwise, if one type is a VLA whose size is specified, the composite type is a VLA of that size.
</li><li>Otherwise, if one type is a VLA of unspecified size, the composite type is a VLA of unspecified size.
</li></ul>
</dd></dl>
</td>
<td><span class="t-mark-rev t-since-c99">(since C99)</span></td></tr>
</table>
<dl><dd><ul><li>Otherwise, both types are arrays of unknown size and the composite type is an array of unknown size.
</li></ul>
<dl><dd>The element type of the composite type is the composite type of the two element types.
</dd></dl>
</dd></dl>
<ul><li>If only one type is a function type with a parameter type list (a function prototype), the composite type is a function prototype with the parameter type list.
</li><li>If both types are function types with parameter type lists, the type of each parameter in the composite parameter type list is the composite type of the corresponding parameters.
</li></ul>
<p>These rules apply recursively to the types from which the two types are derived.
</p>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="c source-c"><pre class="de1"><span class="co1">// Given the following two file scope declarations:</span>
<span class="kw4">int</span> f<span class="br0">(</span><span class="kw4">int</span> <span class="br0">(</span><span class="sy2">*</span><span class="br0">)</span><span class="br0">(</span><span class="br0">)</span>, <span class="kw4">double</span> <span class="br0">(</span><span class="sy2">*</span><span class="br0">)</span><span class="br0">[</span><span class="nu0">3</span><span class="br0">]</span><span class="br0">)</span><span class="sy4">;</span>
<span class="kw4">int</span> f<span class="br0">(</span><span class="kw4">int</span> <span class="br0">(</span><span class="sy2">*</span><span class="br0">)</span><span class="br0">(</span><span class="kw4">char</span> <span class="sy2">*</span><span class="br0">)</span>, <span class="kw4">double</span> <span class="br0">(</span><span class="sy2">*</span><span class="br0">)</span><span class="br0">[</span><span class="br0">]</span><span class="br0">)</span><span class="sy4">;</span>
<span class="co1">// The resulting composite type for the function is:</span>
<span class="kw4">int</span> f<span class="br0">(</span><span class="kw4">int</span> <span class="br0">(</span><span class="sy2">*</span><span class="br0">)</span><span class="br0">(</span><span class="kw4">char</span> <span class="sy2">*</span><span class="br0">)</span>, <span class="kw4">double</span> <span class="br0">(</span><span class="sy2">*</span><span class="br0">)</span><span class="br0">[</span><span class="nu0">3</span><span class="br0">]</span><span class="br0">)</span><span class="sy4">;</span></pre></div></div>
<p>For an identifier with internal or external <a href="storage_duration.html" title="c/language/storage duration">linkage</a> declared in a scope in which a prior declaration of that identifier is visible, if the prior declaration specifies internal or external linkage, the type of the identifier at the later declaration becomes the composite type.
</p>
<h3><span class="mw-headline" id="Incomplete_types">Incomplete types</span></h3>
<p>An incomplete type is an object type that lacks sufficient information to determine the size of the objects of that type. An incomplete type may be completed at some point in the translation unit.
</p><p>The following types are incomplete:
</p>
<ul><li> the type <span class="t-c"><span class="mw-geshi c source-c"><span class="kw4">void</span></span></span>. This type cannot be completed.
</li><li> array type of unknown size. It can be completed by a later declaration that specifies the size.
</li></ul>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="c source-c"><pre class="de1"><span class="kw2">extern</span> <span class="kw4">char</span> a<span class="br0">[</span><span class="br0">]</span><span class="sy4">;</span> <span class="co1">// the type of a is incomplete (this typically appears in a header)</span>
<span class="kw4">char</span> a<span class="br0">[</span><span class="nu0">10</span><span class="br0">]</span><span class="sy4">;</span>      <span class="co1">// the type of a is now complete (this typically appears in a source file)</span></pre></div></div>
<ul><li> structure or union type of unknown content. It can be completed by a declaration of the same structure or union that defines its content later in the same scope.
</li></ul>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="c source-c"><pre class="de1"><span class="kw1">struct</span> node <span class="br0">{</span>
  <span class="kw1">struct</span> node <span class="sy2">*</span>next<span class="sy4">;</span> <span class="co1">// struct node is incomplete at this point</span>
<span class="br0">}</span><span class="sy4">;</span> <span class="co1">// struct node is complete at this point</span></pre></div></div>
<h3><span class="mw-headline" id="Type_names">Type names</span></h3>
<p>A type may have to be named in context other than the <a href="declarations.html" title="c/language/declarations">declaration</a>. In these situations, <i>type name</i> is used, which is, grammatically, exactly the same as a list of <i>type-specifiers</i> and <i>type-qualifiers</i>, followed by the <i>declarator</i> (see <a href="declarations.html" title="c/language/declarations">declarations</a>) as would be used to declare a single object or function of this type, except that the identifier is omitted:
</p>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="c source-c"><pre class="de1"><span class="kw4">int</span> n<span class="sy4">;</span> <span class="co1">// declaration of an int</span>
<span class="kw4">sizeof</span><span class="br0">(</span><span class="kw4">int</span><span class="br0">)</span><span class="sy4">;</span> <span class="co1">// use of type name</span>
 
<span class="kw4">int</span> <span class="sy2">*</span>a<span class="br0">[</span><span class="nu0">3</span><span class="br0">]</span><span class="sy4">;</span> <span class="co1">// declaration of an array of 3 pointers to int</span>
<span class="kw4">sizeof</span><span class="br0">(</span><span class="kw4">int</span> <span class="sy2">*</span><span class="br0">[</span><span class="nu0">3</span><span class="br0">]</span><span class="br0">)</span><span class="sy4">;</span> <span class="co1">// use of type name</span>
 
<span class="kw4">int</span> <span class="br0">(</span><span class="sy2">*</span>p<span class="br0">)</span><span class="br0">[</span><span class="nu0">3</span><span class="br0">]</span><span class="sy4">;</span> <span class="co1">// declaration of a pointer to array of 3 int</span>
<span class="kw4">sizeof</span><span class="br0">(</span><span class="kw4">int</span> <span class="br0">(</span><span class="sy2">*</span><span class="br0">)</span><span class="br0">[</span><span class="nu0">3</span><span class="br0">]</span><span class="br0">)</span><span class="sy4">;</span> <span class="co1">// use of type name</span>
 
<span class="kw4">int</span> <span class="br0">(</span><span class="sy2">*</span>a<span class="br0">)</span><span class="br0">[</span><span class="sy2">*</span><span class="br0">]</span> <span class="co1">// declaration of pointer to VLA (in a function parameter)</span>
<span class="kw4">sizeof</span><span class="br0">(</span><span class="kw4">int</span> <span class="br0">(</span><span class="sy2">*</span><span class="br0">)</span><span class="br0">[</span><span class="sy2">*</span><span class="br0">]</span><span class="br0">)</span> <span class="co1">// use of type name (in a function parameter)</span>
 
<span class="kw4">int</span> <span class="sy2">*</span>f<span class="br0">(</span><span class="kw4">void</span><span class="br0">)</span><span class="sy4">;</span> <span class="co1">// declaration of function</span>
<span class="kw4">sizeof</span><span class="br0">(</span><span class="kw4">int</span> <span class="sy2">*</span><span class="br0">(</span><span class="kw4">void</span><span class="br0">)</span><span class="br0">)</span><span class="sy4">;</span> <span class="co1">// use of type name</span>
 
<span class="kw4">int</span> <span class="br0">(</span><span class="sy2">*</span>p<span class="br0">)</span><span class="br0">(</span><span class="kw4">void</span><span class="br0">)</span><span class="sy4">;</span> <span class="co1">// declaration of pointer to function</span>
<span class="kw4">sizeof</span><span class="br0">(</span><span class="kw4">int</span> <span class="br0">(</span><span class="sy2">*</span><span class="br0">)</span><span class="br0">(</span><span class="kw4">void</span><span class="br0">)</span><span class="br0">)</span><span class="sy4">;</span> <span class="co1">// use of type name</span>
 
<span class="kw4">int</span> <span class="br0">(</span><span class="sy2">*</span><span class="kw4">const</span> a<span class="br0">[</span><span class="br0">]</span><span class="br0">)</span><span class="br0">(</span><span class="kw4">unsigned</span> <span class="kw4">int</span>, ...<span class="br0">)</span> <span class="sy1">=</span> <span class="br0">{</span><span class="nu0">0</span><span class="br0">}</span><span class="sy4">;</span> <span class="co1">// array of pointers to functions</span>
<span class="kw4">sizeof</span><span class="br0">(</span><span class="kw4">int</span> <span class="br0">(</span><span class="sy2">*</span><span class="kw4">const</span> <span class="br0">[</span><span class="br0">]</span><span class="br0">)</span><span class="br0">(</span><span class="kw4">unsigned</span> <span class="kw4">int</span>, ...<span class="br0">)</span><span class="br0">)</span><span class="sy4">;</span> <span class="co1">// use of type name</span></pre></div></div>
<p>Except the redundant parentheses around the identifier are meaningful in a type-name and represent "function with no parameter specification":
</p>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="c source-c"><pre class="de1"><span class="kw4">int</span> <span class="br0">(</span>n<span class="br0">)</span><span class="sy4">;</span> <span class="co1">// declares n of type int</span>
<span class="kw4">sizeof</span><span class="br0">(</span><span class="kw4">int</span> <span class="br0">(</span><span class="br0">)</span><span class="br0">)</span><span class="sy4">;</span> <span class="co1">// uses type "function returning int"</span></pre></div></div>
<p>Type names are used in the following situations:
</p>
<ul><li> <a href="cast.html" title="c/language/cast">cast</a>
</li><li> <a href="sizeof.html" title="c/language/sizeof">sizeof</a>
</li></ul>
 <table class="t-rev-begin">
<tr class="t-rev t-since-c99"><td>
<ul><li> <a href="compound_literal.html" title="c/language/compound literal">compound literal</a>
</li></ul>
</td>
<td><span class="t-mark-rev t-since-c99">(since C99)</span></td></tr>
<tr class="t-rev t-since-c11"><td>
<ul><li> <a href="generic.html" title="c/language/generic">generic selection</a>
</li><li> <a href="_Alignof.html" title="c/language/ Alignof">_Alignof</a>
</li><li> <a href="_Alignas.html" title="c/language/ Alignas">_Alignas</a>
</li><li> <a href="atomic.html" title="c/language/atomic">_Atomic</a> (when used as a type specifier)
</li></ul>
</td>
<td><span class="t-mark-rev t-since-c11">(since C11)</span></td></tr>
</table>
<p><br>
A type name may introduce a new type: 
</p>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="c source-c"><pre class="de1"><span class="kw4">void</span><span class="sy2">*</span> p <span class="sy1">=</span> <span class="br0">(</span><span class="kw4">void</span><span class="sy2">*</span><span class="br0">)</span><span class="br0">(</span><span class="kw1">struct</span> X <span class="br0">{</span><span class="kw4">int</span> i<span class="sy4">;</span><span class="br0">}</span> <span class="sy2">*</span><span class="br0">)</span><span class="nu0">0</span><span class="sy4">;</span>
<span class="co1">// type name "struct X {int i;}*" used in the cast expression</span>
<span class="co1">// introduces the new type "struct X"</span>
<span class="kw1">struct</span> X x <span class="sy1">=</span> <span class="br0">{</span><span class="nu0">1</span><span class="br0">}</span><span class="sy4">;</span> <span class="co1">// struct X is now in scope</span></pre></div></div>
<h3><span class="mw-headline" id="References">References</span></h3>
<div class="t-ref-std-17">
<ul><li> C17 standard (ISO/IEC 9899:2018): 
</li></ul>
<dl><dd><ul><li> 6.2.5 Types (p: 31-33)
</li></ul>
</dd></dl>
<dl><dd><ul><li> 6.2.6 Representations of types (p: 31-35)
</li></ul>
</dd></dl>
<dl><dd><ul><li> 6.2.7 Compatible type and composite type (p: 35-36)
</li></ul>
</dd></dl>
</div>
<div class="t-ref-std-11">
<ul><li> C11 standard (ISO/IEC 9899:2011): 
</li></ul>
<dl><dd><ul><li> 6.2.5 Types (p: 39-43)
</li></ul>
</dd></dl>
<dl><dd><ul><li> 6.2.6 Representations of types (p: 44-46)
</li></ul>
</dd></dl>
<dl><dd><ul><li> 6.2.7 Compatible type and composite type (p: 47-48)
</li></ul>
</dd></dl>
</div>
<div class="t-ref-std-c99">
<ul><li> C99 standard (ISO/IEC 9899:1999): 
</li></ul>
<dl><dd><ul><li> 6.2.5 Types (p: 33-37)
</li></ul>
</dd></dl>
<dl><dd><ul><li> 6.2.6 Representations of types (p: 37-40)
</li></ul>
</dd></dl>
<dl><dd><ul><li> 6.2.7 Compatible type and composite type (p: 40-41)
</li></ul>
</dd></dl>
</div>
<div class="t-ref-std-c89">
<ul><li> C89/C90 standard (ISO/IEC 9899:1990): 
</li></ul>
<dl><dd><ul><li> 3.1.2.5 Types 
</li></ul>
</dd></dl>
<dl><dd><ul><li> 3.1.2.6 Compatible type and composite type 
</li></ul>
</dd></dl>
</div>
<h3><span class="mw-headline" id="See_also">See also</span></h3>
<table class="t-dsc-begin">

</table>

<!-- 
NewPP limit report
Preprocessor visited node count: 2772/1000000
Preprocessor generated node count: 5919/1000000
Post‐expand include size: 44243/2097152 bytes
Template argument size: 9758/2097152 bytes
Highest expansion depth: 13/40
Expensive parser function count: 0/100
-->

<!-- Saved in parser cache with key mwiki1-mwiki_en_:pcache:idhash:13744-0!*!0!!en!*!* and timestamp 20220605010214 -->
</div>                    <!-- /bodycontent -->
                                        <!-- printfooter -->
                    <div class="printfooter">
                    Retrieved from "<a href="https://en.cppreference.com/mwiki/index.php?title=c/language/type&amp;oldid=136122">https://en.cppreference.com/mwiki/index.php?title=c/language/type&amp;oldid=136122</a>"                    </div>
                    <!-- /printfooter -->
                                                            <!-- catlinks -->
                    <!-- /catlinks -->
                                                            <div class="visualClear"></div>
                    <!-- debughtml -->
                                        <!-- /debughtml -->
                </div>
                <!-- /bodyContent -->
            </div>
        </div>
        <!-- /content -->
        <!-- footer -->
        <div id="cpp-footer-base" class="noprint">
            <div id="footer">
                        <div id="cpp-navigation">
            <h5>Navigation</h5>
            <ul><li><a href="https://en.cppreference.com/w/c/language/type">Online version</a></li><li>Offline version retrieved 2022-07-30 14:05.</li></ul></div>
                        <ul id="footer-info">
                                    <li id="footer-info-lastmod"> This page was last modified on 6 December 2021, at 07:13.</li>
                                    <li id="footer-info-viewcount">This page has been accessed 135,314 times.</li>
                            </ul>
                    </div>
        </div>
        <!-- /footer -->
        <script>if(window.mw){
mw.loader.state({"site":"loading","user":"missing","user.groups":"ready"});
}</script>
<script src="../../../common/skin_scripts.js"></script>
<script>if(window.mw){
mw.loader.load(["mediawiki.action.view.postEdit","mediawiki.user","mediawiki.page.ready","mediawiki.searchSuggest","mediawiki.hidpi","ext.gadget.ColiruCompiler","ext.gadget.MathJax"], null, true);
}</script>
<script src="../../../common/site_scripts.js"></script>
<script type="text/javascript">
var _gaq = _gaq || [];
_gaq.push(['_setAccount', 'UA-2828341-1']);
_gaq.push(['_setDomainName', 'cppreference.com']);
_gaq.push(['_trackPageview']);
</script><!-- Served in 1.473 secs. -->
	</body>
<!-- Cached 20220605010214 -->
</html>